﻿using System;

// 泛型栈类（包含Min方法）
public class MyStack<T> where T : IComparable<T>
{
    public T[] Items;       // 主栈：存储元素
    private int _top;       // 主栈栈顶索引（-1表示空）
    private T[] _minItems;  // 辅助栈：存储对应位置的最小值
    private int _minTop;    // 辅助栈栈顶索引

    /// <summary>
    /// 构造函数：初始化栈容量
    /// </summary>
    public MyStack(int capacity)
    {
        if (capacity <= 0)
            throw new ArgumentException("容量必须大于0", nameof(capacity));
        Items = new T[capacity];
        _minItems = new T[capacity]; // 辅助栈容量与主栈一致
        _top = -1;
        _minTop = -1;
    }

    /// <summary>
    /// 初始化栈（重置为空）
    /// </summary>
    public void InitStack()
    {
        _top = -1;
        _minTop = -1;
    }

    /// <summary>
    /// 清空栈
    /// </summary>
    public void ClearStack()
    {
        InitStack(); // 复用初始化逻辑
    }

    /// <summary>
    /// 入栈
    /// </summary>
    public bool Push(T item)
    {
        // 栈满则入栈失败
        if (_top == Items.Length - 1)
            return false;

        // 主栈入栈
        _top++;
        Items[_top] = item;

        // 辅助栈维护最小值：空则直接入栈，否则入较小值
        if (_minTop == -1)
        {
            _minTop++;
            _minItems[_minTop] = item;
        }
        else
        {
            T currentMin = _minItems[_minTop];
            T newMin = item.CompareTo(currentMin) < 0 ? item : currentMin;
            _minTop++;
            _minItems[_minTop] = newMin;
        }
        return true;
    }

    /// <summary>
    /// 出栈
    /// </summary>
    public T Pop()
    {
        if (_top == -1)
            throw new InvalidOperationException("栈为空，无法出栈");

        // 主栈出栈
        T topItem = Items[_top];
        _top--;

        // 辅助栈同步出栈
        _minTop--;

        return topItem;
    }

    /// <summary>
    /// 获取栈中最小值
    /// </summary>
    public T Min()
    {
        if (_minTop == -1)
            throw new InvalidOperationException("栈为空，无最小值");
        return _minItems[_minTop];
    }
}

// 包含入口点Main方法的类
class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 1. 初始化一个容量为5的int类型栈
            MyStack<int> stack = new MyStack<int>(5);
            Console.WriteLine("初始化栈完成（容量5）");

            // 2. 测试入栈操作
            stack.Push(3);
            stack.Push(1);
            stack.Push(4);
            stack.Push(2);
            Console.WriteLine("入栈元素：3,1,4,2");

            // 3. 测试Min方法（当前最小值应为1）
            Console.WriteLine($"当前栈中最小值：{stack.Min()}"); // 输出：1

            // 4. 测试出栈操作
            int popItem = stack.Pop();
            Console.WriteLine($"出栈元素：{popItem}（剩余元素：3,1,4）");
            Console.WriteLine($"出栈后最小值：{stack.Min()}"); // 输出：1

            // 5. 继续出栈
            popItem = stack.Pop();
            Console.WriteLine($"出栈元素：{popItem}（剩余元素：3,1）");
            Console.WriteLine($"出栈后最小值：{stack.Min()}"); // 输出：1

            // 6. 清空栈
            stack.ClearStack();
            Console.WriteLine("清空栈后，尝试获取最小值：");
            Console.WriteLine(stack.Min()); // 会抛出异常（栈为空）
        }
        catch (Exception ex)
        {
            Console.WriteLine($"错误：{ex.Message}");
        }
    }
}